import {
	mergeConfig,
	dispatchRequest,
	jsonpRequest
} from "./utils"

export default class request {

	constructor(options) {
		// 请求公共地址
		this.baseUrl = options.baseUrl || "";
		// 公共文件上传请求地址
		this.fileUrl = options.fileUrl || "";
		// 超时时间
		this.timeout = options.timeout || 6000;
		// 服务器上传图片默认url
		this.defaultUploadUrl = options.defaultUploadUrl || "";
		// 默认请求头
		this.header = options.header || {};
		// 默认配置
		this.config = options.config || {
			isPrompt: true,
			load: true,
			isFactory: true,
			resend: 0
		};
	}
	
	// post请求
	post(url = '', data = {}, options = {}) {
	  return this.request({
	    method: "POST",
	    data: data,
	    url: url,
	    ...options
	  });
	}
	
	// get请求
	get(url = '', data = {}, options = {}) {
	  return this.request({
	    method: "GET",
	    data: data,
	    url: url,
	    ...options
	  });
	}
	
	// put请求
	put(url = '', data = {}, options = {}) {
	  return this.request({
	    method: "PUT",
	    data: data,
	    url: url,
	    ...options
	  });
	}
	
	// delete请求
	delete(url = '', data = {}, options = {}) {
	  return this.request({
	    method: "DELETE",
	    data: data,
	    url: url,
	    ...options
	  });
	}
	
	// jsonp请求(只限于H5使用)
	jsonp(url = '', data = {}, options = {}) {
	  return this.request({
	    method: "JSONP",
	    data: data,
	    url: url,
	    ...options
	  });
	}
	
	// 接口请求方法
	async request(data) {
		// 请求数据
		let requestInfo,
			// 是否运行过请求开始的钩子
			runRequestStart = false;
		try {
			if(!data.url) {
				throw {
					errMsg: '【request】缺失数据url',
					statusCode: 0
				}
			}
			// 数据合并
			requestInfo = mergeConfig(this, data)
      // 代表之前运行到这里
      runRequestStart = true;
      // 请求前回调，请求拦截器 相当于interceptors.request.use
      if(this.requestStart) {
				// 请求拦截器：header加入当前终端platform，还有token
        let requestStart = this.requestStart(requestInfo);
        if(typeof requestStart == 'object') {
          let changekeys = ['data', 'header', 'isPrompt', 'load', 'isFactory'];
          changekeys.forEach(key => {
            requestInfo[key] = requestStart[key];
          })
        } else {
          throw {
            errMsg: "【request】请求开始拦截器未通过",
            statusCode: 0,
            data: requestInfo.data,
            method: requestInfo.method,
            header: requestInfo.header,
            url: requestInfo.url,
          }
        }
      }
      
      let requestResult = {}
      if(requestInfo.method == 'JSONP') {
        requestResult = await jsonRequest(requestInfo);
      } else {
        requestResult = await dispatchRequest(requestInfo);
      }
      // 是否使用外部数据处理方法
			if(requestInfo.isFactory && this.dataFactory) {
				// 数据处理
				let result = await this.dataFactory({
					...requestInfo,
					response: requestResult
				})
				// 数据响应
				return Promise.resolve(result);
			} else {
				// 数据响应
				return Promise.resolve(requestResult)
			} 
		} catch(err) {
			this.requestError && this.requestError(err);
			return Promise.reject(err);
		} finally {
			// 如果请求请求开始未运行到，请求结束也不运行
			if(runRequestStart) {
				this.requestEnd && this.requestEnd(requestInfo)
			}
		}
	}
	
	
}
